package com.example.utils;

import com.example.entity.AirZone;
import com.example.entity.CapacityInformationAirspace;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Utils {

    public static void main(String[] args) {
        AirZone airZone = parseString2AirZone("空域5-3");
        System.out.println(airZone);
        String airZoneStr = parseAirZone2String(airZone);
        System.out.println(airZoneStr);
        CapacityInformationAirspace alarmInfo = mockAlarmInformation(airZone, LocalDateTime.now());
        System.out.println(alarmInfo);
        List<CapacityInformationAirspace> alarmList = mockThisTimeAlarmInformation(2, 5, LocalDateTime.now());
        System.out.println(alarmList);
    }

    // 将字符串解析为 AirZone 对象
    public static AirZone parseString2AirZone(String str) {
        // 检查字符串是否为空或不包含 "-"
        if (str == null || !str.contains("-")) {
            return null; // 如果不符合条件，返回 null
        }

        // 使用 "-" 分割字符串
        String[] parts = str.split("-");
        if (parts.length != 2) {
            return null; // 如果分割后的数组长度不为 2，返回 null
        }

        try {
            // 提取数字部分并转换为整数，分别作为层 ID 和区域 ID
            int layerId = Integer.parseInt(parts[0].replaceAll("[^0-9]", ""));
            int zoneId = Integer.parseInt(parts[1].replaceAll("[^0-9]", ""));
            return new AirZone(layerId, zoneId); // 创建新的 AirZone 对象并返回
        } catch (NumberFormatException e) {
            return null; // 如果转换失败，返回 null
        }
    }

    // 将 AirZone 对象转换为字符串
    public static String parseAirZone2String(AirZone airZone) {
        if (airZone == null) {
            return null; // 如果 AirZone 对象为空，返回 null
        }
        // 返回拼接的字符串，格式为 "层ID-区域ID"
        return "空域" + airZone.getLayerId() + "-" + airZone.getZoneId();
    }

    // 随机生成一个 CapacityInformationAirspace 对象
    public static CapacityInformationAirspace mockAlarmInformation(AirZone airZone, LocalDateTime time) {
        // 检查输入参数是否为空
        if (airZone == null || time == null) {
            return null; // 如果任何一个参数为空，返回 null
        }

        // 使用 AirZone 对象生成空域编号字符串
        String airspaceNumber = parseAirZone2String(airZone);

        // 创建随机数生成器
        Random random = new Random();

        // 随机生成警报等级，范围为 1 到 3
        int alertLevel = random.nextInt(4) + 1;
        // 随机生成空域流量，范围为 0 到 100
        int airspaceFlow = random.nextInt(101);
        // 随机生成空域容量，范围为 0 到 100
        int airspaceCapacity = random.nextInt(101);
        // 随机生成路线信息编号，范围为 1 到 10
        int routeInfo = random.nextInt(10) + 1;
        // 随机生成空域类型，范围为 1 到 3
        int airspaceType = random.nextInt(3) + 1;

        // 创建并返回新的 CapacityInformationAirspace 对象，包含 airspaceType
        String airspaceSize = null;
        return new CapacityInformationAirspace(airspaceNumber, airspaceType, null,time, alertLevel, airspaceFlow, airspaceCapacity, routeInfo);
    }

    // 根据最大层数和区域编号生成 CapacityInformationAirspace 列表
    public static List<CapacityInformationAirspace> mockThisTimeAlarmInformation(Integer layerMax, Integer zoneMax, LocalDateTime time) {
        // 创建用于存储 CapacityInformationAirspace 对象的列表
        List<CapacityInformationAirspace> alarmList = new ArrayList<>();

        // 遍历每一个层ID和区域ID的组合
        for (int layerId = 1; layerId <= layerMax; layerId++) {
            for (int zoneId = 1; zoneId <= zoneMax; zoneId++) {
                // 创建新的 AirZone 对象
                AirZone airZone = new AirZone(layerId, zoneId);
                // 使用 AirZone 对象和时间生成 CapacityInformationAirspace 对象
                CapacityInformationAirspace alarmInfo = mockAlarmInformation(airZone, time);
                // 将生成的 CapacityInformationAirspace 对象添加到列表中
                alarmList.add(alarmInfo);
            }
        }

        // 返回生成的 CapacityInformationAirspace 列表
        return alarmList;
    }
}

